/*
 * SOFTWARE PARA SPEED TRANSPORTES CLASSE DE COMUNICACAO ENTRE MODELO BANCO E INTERFACE
 * PESSOAS DO PROJETO: SILVIO, FERNANDO, GUILHERME, LUAN
 * VERSAO 1.5
 * MODIFICAÇÔES 25/10/2011
 * 1- alterar o desing dos campos de endereço do cliente
 * 2- alterar o desing dos campo de endereço do motorista
 * 3- alterar a ordem de cadastro dos campos do motorista
 * 4- alterar o desing de referencias pessoais do motorista
 * 5- incluir campo complemento no endereço de todos.
 * MODIFICAÇÕES 31/10/2011
 * 1- alterar a atualizacao de dados
 * 2- alterar a busca de motoristas com a cnh vencida
 * 3- modificação no faturamento de funcionario
 * 4- Incremento do 'aguarde' nas consultas
 * 5- alteração na consulta de proprietarios que estava errada
 * 6- Colocar cada palavra para começar com a letra maiuscula
 * 7- Verificação do .jar que estava inconsistente
 * MODIFICAÇÕES 05/11/2011
 * 1- Busca de proprietarios agora aceita qualquer coisa relacionada
 * 2- Busca de clientes volta todos em ordem alfabetica
 * 3- Mascara de transformação de numeros verificada
 * 4- Verificação dos SetSelectItem nos estados
 * 5- Fechar faturas agora com somente um valor
 */

package Controle;

import Formulario.GerarGrafico;
import Modelo.*;
import Persistencia.Arquivo;
import Persistencia.BancoDeDados;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.jfree.chart.ChartPanel;
/**
 *
 * @author Silvio
 */
public class Controlador {
     //atributo static para manusear o banco de dados, ele e estatico pois todos tem acesso a ele
    private static BancoDeDados bd;
    private static Funcionario funcLogado;
    private static Emp empresa;
    private static Arquivo arq;


    public static Emp getEmp(){
        return empresa;
    }

    public static Funcionario getFuncLogado(){
        return funcLogado;
    }

    //metodo para retornar o banco para quem precisar
    public static BancoDeDados getBd() {
        return bd;
    }

    //metodo para setar o caminho da conexao usuario e senha do banco
        public static String IniciaBanco(){
            arq = new Arquivo();
            arq.Leitura();

            String con="Erro ao iniciar o Banco";
            try {
                bd = new BancoDeDados( arq.getUsuario(), arq.getSenha(),"jdbc:mysql://"+arq.getIp()+":"+arq.getPorta()+"/speed");
                if(bd.Conectar()){
                    con = "Inicio do Banco OK";
                    bd.Desconetar();
                }else{
                     bd =null;
                }
                return con;
            } catch (Exception ex) {
                bd =null;
                return "Erro ao iniciar o Banco";
            }
        }

/***************************************************************************
 * *********************************MOTORISTA*******************************
 * ************************************************************************
 *
 */
         public static String cadastroMotorista(String nome,String dataNascimento,String CPF, String telefone,
                String CNH,String categoriaCNH,String RG,String UF,String orgExpedidor,String bairro,String endereco,
                String cidade,String estado,String CEP,String celular,String nomePai,
                String nomeMae,String obs,String numEnd,String validadeCNH, String referenciaPessoal,String telefoneReferencia,String apelido,String complemento){

             

                Data dataNascimento2 = new Data(dataNascimento);
                Data validadeCNH2 = new Data(validadeCNH);


                try {
                    Motorista mot = new  Motorista(nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,CPF,UF,orgExpedidor,RG,CNH,categoriaCNH,nomePai,nomeMae,validadeCNH2,referenciaPessoal,celular,dataNascimento2,obs,telefoneReferencia,apelido,complemento);
                    String query = queryMotoristaInsert(mot);
                    System.out.println(query);
                    bd.Conectar();
                    bd.insercao(query);
                    bd.Desconetar();
                    return "Cadastro realizado com sucesso";
                } catch (Exception ex) {
                    bd.Desconetar();
                    return "Erro no cadastro";
                }
        }

         
         public static void montObjMotorista(String dados[][],ArrayList <Motorista> motorista){
             
             for(int i=0;i<dados.length;i++){
                    try {
                        Data dataNascimento = new Data();
                        dataNascimento.dataBanco(dados[i][23]);
                        Data validadeCNH = new Data();
                        validadeCNH.dataBanco(dados[i][19]);
                        Motorista mot = new Motorista(dados[i][0], dados[i][1], dados[i][2], dados[i][3], dados[i][4], dados[i][5], dados[i][6],
                                dados[i][7], Integer.parseInt(dados[i][9]), dados[i][10], dados[i][11], dados[i][13], dados[i][12], dados[i][14],
                                dados[i][15], dados[i][16], dados[i][17], validadeCNH, dados[i][20], dados[i][22], dataNascimento, dados[i][18], dados[i][21], Uteis.transformaInt(dados[i][8]),dados[i][24],dados[i][25]);
                        motorista.add(mot);
                    } catch (Exception ex) {  }
                }
         }

        /*chave campo que o cliente digitou, tipo 1 = ID, 2 = CPF, 3 = nome*/
         public static ArrayList<Motorista> consultarMotorista(String chave, int tipo){
                ArrayList <Motorista> motorista = new ArrayList<Motorista>();
                String query = queryConsultaMotorista(chave,tipo);
                String dados[][];
            try {
                bd.Conectar();
                dados = bd.selecao(query);
                bd.Desconetar();
                montObjMotorista(dados,motorista);
                
             } catch (SQLException ex) {
                 bd.Desconetar();
                return null;
             }
             return motorista;
         }



         public static String removerMotorista(Motorista mot){
             System.out.println(mot.getId());
             String query = queryRemoveMotorista(mot);
             System.out.println(query);
             try{
                bd.Conectar();
                bd.insercao(query);
                bd.Desconetar();
                return "Remoção feita";
             }catch(Exception ex){
                 bd.Desconetar();
                return "erro ao remover, o motorista esta sendo utilizado";
             }
         }

            public static String alterarMotorista(Motorista mot,String nome,String dataNascimento,String CPF,
                String CNH,String categoriaCNH,String RG,String UF,String orgExpedidor,String bairro,String endereco,
                String cidade,String Estado,String CEP,String telFixo,String celular,String nomePai,
                String nomeMae,String obs,String numEnd,String validadeCNH, String referenciaPessoal,String telefoneReferencia,String apelido,String complemento){
            try{

               
         
                Data dataNascimento2 = new Data(dataNascimento);
                Data validadeCNH2 = new Data(validadeCNH);

               mot.setCNH(CNH);
               mot.setCPF(CPF);
               mot.setCategoriaCNH(categoriaCNH);
               mot.setCelular(celular);
               mot.setDataNascimento(dataNascimento2);
               mot.setBairro(bairro);
               mot.setCEP(CEP);
               mot.setCidade(cidade);
               mot.setEndereco(endereco);
               mot.setEstado(Estado);
               mot.setNumEnd(numEnd);
               mot.setNome(nome);
               mot.setNomeMae(nomeMae);
               mot.setNomePai(nomePai);
               mot.setObs(obs);
               mot.setRG(RG);
               mot.setUfRG(UF);
               mot.setOrgExRG(orgExpedidor);
               mot.setReferenciaPessoal(referenciaPessoal);
               mot.setTelefone(telFixo);
               mot.setTelefoneReferencia(telefoneReferencia);
               mot.setValidadeCNH(validadeCNH2);
               mot.setApelido(apelido);
               mot.setComplemento(complemento);
               String query = queryMotoristaAltera(mot);
               bd.Conectar();
               bd.insercao(query);
               bd.Desconetar();
               return "Alteraçao feita";
           }catch(SQLException ex){
               bd.Desconetar();
               return "Erro ao alterar os dados no banco";
           } catch (Exception ex) {
               return "Erro ao alterar os dados do motorista";
           }


       }
       /*
        *************************************************************************
        ***************************** FUNCIONÁRIO *******************************
        *************************************************************************/

            public static String cadastroFuncionario(String nome, String CPF, String telefone, String celular,
               String endereco, String dataNascimento, String RG, String login, String senha, String bairro,
               String cidade, String numEnd, String CEP, String estado, String UF, String orgExpedidor,String nivelAcesso,String valorCaixa,String complemento){

                
                
              
                if(!Uteis.soContemNumeros(nivelAcesso))
                    return "Nivel de acesso invalido";
                Data dataNascimento2 = new Data(dataNascimento);

                try {
                    Funcionario func = new  Funcionario(nome,telefone,endereco,CEP,numEnd,bairro, estado,
                            cidade,CPF,UF,orgExpedidor,RG,login,senha,dataNascimento2,celular,Uteis.transformaInt(nivelAcesso),Uteis.transformaFloat(valorCaixa),complemento);

                    String query = queryFuncionarioInsert(func);
                    bd.Conectar();
                    bd.insercao(query);
                    bd.Desconetar();
                    return "Cadastro realizado com sucesso";
                } catch (Exception ex) {
                    bd.Desconetar();
                    return "Erro no cadastro";
                }
        }


        public static void montObjFuncionario(String dados[][],ArrayList <Funcionario> funcionario){
            for(int i=0;i<dados.length;i++){
                    try {
                        Data dataNascimento = new Data();
                        dataNascimento.dataBanco(dados[i][17]);
                        Funcionario func = new Funcionario(dados[i][0], dados[i][1],
                                dados[i][2], dados[i][3], dados[i][4], dados[i][5],
                                dados[i][6], dados[i][7], Integer.parseInt(dados[i][9]),
                                dados[i][10], dados[i][11], dados[i][13], dados[i][12], dados[i][14],
                                dados[i][15], dataNascimento, dados[i][16], Uteis.transformaInt(dados[i][8]),Uteis.transformaInt(dados[i][18]),Uteis.transformaFloat(dados[i][19]),dados[i][20]);
                        funcionario.add(func);
                    } catch (Exception ex) {  }
                }
        }
            
         /*chave campo que o cliente digitou, tipo 1 = ID, 2 = CPF, 3 = nome*/
        public static ArrayList<Funcionario> consultarFuncionario(String chave, int tipo){
                ArrayList <Funcionario> funcionario = new ArrayList<Funcionario>();

                String query = queryConsultaFuncionario(chave,tipo);
                String dados[][];
            try {
                bd.Conectar();
                dados = bd.selecao(query);
                bd.Desconetar();
                montObjFuncionario(dados,funcionario);
             } catch (SQLException ex) {
                 bd.Desconetar();
                return null;
             }
             return funcionario;
         }


         public static String removerFuncionario(Funcionario func) {
            String query = queryRemoveFuncionario(func);
             try{
                bd.Conectar();
                bd.insercao(query);
                bd.Desconetar();
                return "Remoção feita";
             }catch(Exception ex){
                 bd.Desconetar();
                return "erro ao remover o funcionario esta sendo utilizado";
             }
         }

         public static String alterarFuncionario(Funcionario func,String nome, String CPF, String telefone, String celular,
               String endereco, String dataNascimento, String RG, String login, String senha, String bairro,
               String cidade, String numEnd, String CEP, String estado, String UF, String orgExpedidor, String valorCaixa,String complemento){

              try{
               
              
                Data dataNascimento2 = new Data(dataNascimento);

               func.setCPF(CPF);
               func.setCelular(celular);
               func.setDataNascimento(dataNascimento2);
               func.setBairro(bairro);
               func.setCEP(CEP);
               func.setCidade(cidade);
               func.setEndereco(endereco);
               func.setEstado(estado);
               func.setNumEnd(numEnd);
               func.setNome(nome);
               func.setRG(RG);
               func.setUfRG(UF);
               func.setOrgExRG(orgExpedidor);
               func.setTelefone(telefone);
               func.setLogin(login);
               func.setSenha(senha);
               func.setValorCaixa(Uteis.transformaFloat(valorCaixa));
               func.setComplemento(complemento);
               String query = queryFuncionarioAlterar(func);
               bd.Conectar();
               bd.insercao(query);
               bd.Desconetar();
               return "Alteração feita";
           }catch(SQLException ex){
               bd.Desconetar();
                return "Erro ao alterar os dados no banco";
           }catch (Exception ex) {
               return "Erro ao alterar os dados do funcionario";
           }


       }

       /*
        * *****************************************************************************
        * ******************************** CLIENTE FISICO *****************************
        * *****************************************************************************
        */
       public static String cadastroFisico(String nome, String CPF, String telefone, String telfax,
               String endereco, String RG, String taxa, String valFixo, String bairro, String estado, String orgExRG,
               String cidade, String numEnd, String CEP, String email, String UF, String outrasInf, String desconto,String nomeFatura,String complemento){

                 if(Uteis.transformaFloat(valFixo) < 0)
                    return "Valor Fixo invalido";
                if(Uteis.transformaFloat(taxa) < 0)
                    return "Taxa invalido";

             
                PessoaFisica pessoa = new PessoaFisica(nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,CPF,UF,orgExRG,RG,complemento);
                float tempTaxa = Uteis.transformaFloat(taxa)/10;
                float tempDesc = Uteis.transformaFloat(desconto)/100;
                try {

                    Fisico fis = new  Fisico(telfax,email,outrasInf,tempTaxa,
                    Uteis.transformaFloat(valFixo),tempDesc,pessoa,nomeFatura);

                     String query = queryFisicoInsert(fis);
                     bd.Conectar();
                     bd.insercao(query);
                     bd.Desconetar();

                    return "Cadastro realizado com sucesso";
                } catch (Exception ex) {
                    bd.Desconetar();
                    return "Erro no cadastro";
                }
        }


       public static ArrayList <Fisico> montObjFisico(String dados[][]){
           ArrayList <Fisico> fisico = new ArrayList<Fisico>();
           for(int i=0;i<dados.length;i++){
                    try {
                        PessoaFisica pessoa = new PessoaFisica(Uteis.transformaInt(dados[i][19]),dados[i][0],
                        dados[i][1],dados[i][2],dados[i][3],dados[i][4],dados[i][5],dados[i][6], dados[i][7],
                        Uteis.transformaInt(dados[i][20]),dados[i][9],dados[i][10],dados[i][12],dados[i][11],dados[i][22]);
                        Fisico fis = new Fisico(Uteis.transformaInt(dados[i][8]), dados[i][13], dados[i][14], dados[i][15], Uteis.transformaFloat(dados[i][16]), Uteis.transformaFloat(dados[i][17]), Uteis.transformaFloat(dados[i][18]), pessoa,dados[i][21]);
                        fisico.add(fis);
                    } catch (Exception ex) {  }
                }
           return fisico;
       }

        /*CHAVE valor passado para pesquisa tipo 1=ID, 2= CPF, 3= Nome*/
        public static ArrayList<Fisico> consultarFisico(String chave, int tipo){
                ArrayList <Fisico> fisico = new ArrayList<Fisico>();
                String query = queryConsultaFisico(chave,tipo);
                String dados[][];
            try {
                bd.Conectar();
                dados = bd.selecao(query);
                bd.Desconetar();
                fisico.addAll(montObjFisico(dados));
             } catch (SQLException ex) {
                bd.Desconetar();
                return fisico;
             }
             return fisico;
         }


         public static String removerFisico(Fisico fis) {
            String query = queryRemoveFisico(fis);
             try{
                bd.Conectar();
                bd.insercao(query);
                bd.Desconetar();
                return "Remoção feita";
             }catch(Exception ex){
                 bd.Desconetar();
                return "erro ao remover, cliente já esta sendo utilizado";
             }
         }

         public static String alterarFisico(Fisico fis,String nome, String CPF, String telefone, String telfax,
               String endereco, String RG, String taxa, String valFixo, String bairro, String cidade, String estado,
               String numEnd, String CEP, String email, String UF, String orgExRG, String outrasInf, String desconto, String nomeFaturante,String complemento){

             try{
            
                if(Uteis.transformaFloat(valFixo) < 0)
                    return "Valor Fixo invalido";
                if(Uteis.transformaFloat(taxa) < 0)
                    return "Taxa invalido";

            
                PessoaFisica pessoa = new PessoaFisica(nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,CPF,UF,orgExRG,RG,complemento);
                pessoa.setIdPessoaFisica(fis.getPessoa().getIdPessoaFisica());
                pessoa.setId(fis.getPessoa().getId());
                fis.setPessoa(pessoa);
                fis.setTelFax(telfax);
                fis.setEmail(email);
                fis.setOutrasInf(outrasInf);
                fis.setTaxa(Uteis.transformaFloat(taxa)/10);
                fis.setValorFixo(Uteis.transformaFloat(valFixo));
                fis.setDesconto(Uteis.transformaFloat(desconto)/100);
                fis.setNomeFaturante(nomeFaturante);
                String query = queryFisicoAlterar(fis);
                
                bd.Conectar();
                bd.insercao(query);
                bd.Desconetar();
               return "Alteração realizada com sucesso";
           }catch(SQLException ex){
                 bd.Desconetar();
                 return "Erro ao alterar os dados no banco";
           }catch (Exception ex) {
               return "Erro ao alterar os dados do cliente fisico";
           }

       }

         /*
          * *************************************************************************
          * *************************** CLIENTE JURIDICO ****************************
          * *************************************************************************
          */

         public static String cadastroJuridico(String nome, String telefone, String endereco, String numEnd, String CEP,
                 String bairro, String estado, String cidade, String CNPJ, String inscricaoEstadual, String nomeFantasia,
                 String telFax, String email, String outrasInf, String taxa, String desconto,String valorFixo,String nomeFaturante,String complemento){

                 if(Uteis.transformaFloat(valorFixo) < 0)
                    return "Valor Fixo invalido";
                if(Uteis.transformaFloat(taxa) < 0)
                    return "Taxa invalido";
                 Pessoa pessoa = new Pessoa(nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,complemento);
                 float tempTaxa = Uteis.transformaFloat(taxa)/10;
                 float tempDesc = Uteis.transformaFloat(desconto)/100;
                try {
                    Juridico jur = new  Juridico(telFax,email,outrasInf,tempTaxa,
                    Uteis.transformaFloat(valorFixo),tempDesc,pessoa,CNPJ,inscricaoEstadual,nomeFantasia,nomeFaturante);
                    String query = queryJuridicoInsert(jur);
                    bd.Conectar();
                    bd.insercao(query);
                    bd.Desconetar();
                    return "Cadastro realizado com sucesso";
                } catch (Exception ex) {
                     bd.Desconetar();
                    return "Erro no cadastro";
                }
         }

         public static ArrayList <Juridico> montObjJuridico(String dados[][]){
             ArrayList <Juridico> juridico = new ArrayList<Juridico>();
             for(int i=0;i<dados.length;i++){
                    try {
                        Pessoa pessoa = new Pessoa(Uteis.transformaInt(dados[i][14]),dados[i][0],
                        dados[i][1],dados[i][2],dados[i][3],dados[i][4],dados[i][5],dados[i][6], dados[i][7],dados[i][20]);

                        Juridico jur = new Juridico(Uteis.transformaInt(dados[i][15]), dados[i][8], dados[i][9],
                                dados[i][10], Uteis.transformaFloat(dados[i][11]), Uteis.transformaFloat(dados[i][12]),
                                Uteis.transformaFloat(dados[i][13]), pessoa, dados[i][16], dados[i][17], dados[i][18],dados[i][19]);
                        juridico.add(jur);
                    } catch (Exception ex) {  }
                }
             return juridico;
         }

         /*tipo 1 = ID, 2 = CNPJ, 3 = nome*/
         public static ArrayList <Juridico> consultaJuridico(String chave, int tipo){
                ArrayList <Juridico> juridico = new ArrayList<Juridico>();

                String query = queryConsultaJuridico(chave,tipo);
                String dados[][];
            try {
                bd.Conectar();
                dados = bd.selecao(query);
                bd.Desconetar();
                juridico.addAll(montObjJuridico(dados));
             } catch (SQLException ex) {
                  bd.Desconetar();
                return juridico;
             }
             return juridico;
         }

         public static String removerJuridico(Juridico jur){
             String query = queryRemoveJuridico(jur);
             try{
                bd.Conectar();
                bd.insercao(query);
                bd.Desconetar();
                return "Remoção feita";
             }catch(Exception ex){
                  bd.Desconetar();
                return "erro ao remover, cliente esta sendo utilizado";
             }
         }

         public static String alterarJuridico(Juridico jur,String nome, String telefone, String endereco, String numEnd,
                 String bairro, String estado, String cidade, String CEP, String CNPJ, String inscricaoEstadual, String nomeFantasia,
                 String telFax, String email, String outrasInf, String taxa, String desconto,String valorFixo,String nomeFaturante,String complemento){
           try{
             
                if(Uteis.transformaFloat(valorFixo) < 0)
                    return "Valor Fixo invalido";
                if(Uteis.transformaFloat(taxa) < 0)
                    return "Taxa invalido";

                Pessoa pessoa = new Pessoa(jur.getPessoa().getId(),nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,complemento);

               jur.setPessoa(pessoa);
               jur.setTelFax(telFax);
               jur.setEmail(email);
               jur.setOutrasInf(outrasInf);
               jur.setTaxa(Uteis.transformaFloat(taxa)/10);
               jur.setValorFixo(Uteis.transformaFloat(valorFixo));
               jur.setDesconto(Uteis.transformaFloat(desconto)/100);
               jur.setCNPJ(CNPJ);
               jur.setIE(inscricaoEstadual);
               jur.setNomeFantasia(nomeFantasia);
               jur.setNomeFaturante(nomeFaturante);
               String query = queryJuridicoAlterar(jur);
               bd.Conectar();
               bd.insercao(query);
               bd.Desconetar();
               return "alteração feita";
           }catch(SQLException ex){
                bd.Desconetar();
                return "Erro ao alterar no banco";
           }catch (Exception ex) {
               return "Erro ao alterar os dados do cliente juridico";
           }
         }

         /*
          * *************************************************************************
          * **************************** CLIENTE ************************************
          * *************************************************************************
          */

         public static ArrayList<Cliente> consultaCliente(String chave, int tipo){
                List cli = new ArrayList<Cliente>();
                cli.addAll(consultarFisico(chave, tipo));
                cli.addAll(consultaJuridico(chave,tipo));
                Collections.sort(cli, new ComparadorDeClientes());
                return (ArrayList<Cliente>) cli;
         }

         public static String removeCliente(Cliente cli){
             String result="erro na remoção";
             if(cli instanceof Juridico){
                 result = removerJuridico((Juridico) cli);
             }else if( cli instanceof Fisico){
                 result = removerFisico((Fisico)cli);
             }
                 return result;
         }
         /*
          * **********************************************************************
          * ****************************** VEICULO *******************************
          * **********************************************************************
          */

         public static String cadastroVeiculo(Pessoa pes, String placa,String cidade,String chassi,String renavam,
                 String TipoCarroceria,String anoFabricacao,String modelo, String fabricante,String cor, String UF){
                 if(anoFabricacao.length()>4 || !Uteis.soContemNumeros(anoFabricacao))
                     return "Ano de fabricacao invalido";
                 if(pes == null)
                     return "Escolha um proprietario";
                try {
                    Veiculo vei = new Veiculo(placa, cidade,UF,chassi, renavam,TipoCarroceria,anoFabricacao,modelo,fabricante, cor, pes);
                    String  query = queryVeiculoInsert(vei);
                    System.out.println(query);
                    bd.Conectar();
                    bd.insercao(query);
                    bd.Desconetar();
                    return "Cadastro realizado com sucesso";
                }catch(SQLException ex){
                     bd.Desconetar();
                   return "Erro no cadastro no banco";
                } catch (Exception ex) {
                    return "Erro no cadastro";
                }
         }

         public static void montObjVeiculo(String dados[][], ArrayList <Veiculo> veiculo){
                  for(int i=0;i<dados.length;i++){
                         
                          Pessoa pes = new Pessoa(Uteis.transformaInt(dados[i][12]),dados[i][13],dados[i][14],dados[i][15],dados[i][16],dados[i][17],dados[i][18],dados[i][19],dados[i][20],dados[i][21]);
                          Veiculo vei = new Veiculo(Uteis.transformaInt(dados[i][0]),dados[i][2],dados[i][3],dados[i][4],dados[i][5],dados[i][6],dados[i][7],dados[i][8],dados[i][9],dados[i][10],dados[i][11],pes);
                          veiculo.add(vei);
                    }
              
         }

         //TIPO = 1 ~> Placa ||||||||||||| TIPO = 2 ~> Renavam
         public static ArrayList<Veiculo> buscarVeiculo(String chave, int tipo){
                ArrayList <Veiculo> veiculo = new ArrayList<Veiculo>();

                String query = queryConsultaVeiculo(chave,tipo);
                String dados[][];
            try {
                bd.Conectar();
                dados = bd.selecao(query);               
                bd.Desconetar();
                 montObjVeiculo(dados,veiculo);
                return veiculo;
             } catch (Exception ex) {
                  bd.Desconetar();
                  return veiculo;
             }
         }
         public static String removerVeiculo(Veiculo vei){
             String query = queryRemoveVeiculo(vei);
             try{
                bd.Conectar();
                bd.insercao(query);
                bd.Desconetar();
                return "Remoção feita";
             }catch(Exception ex){
                  bd.Desconetar();
                return "erro ao remover, o veiculo esta sendo utilizado";
             }
         }

         public static String alterarVeiculo(Veiculo vei,Pessoa pes, String placa,String cidade,String chassi,String renavam,
                 String TipoCarroceria,String anoFabricacao,String modelo, String fabricante,String cor){
             if(anoFabricacao.length()>4 || !Uteis.soContemNumeros(anoFabricacao))
                     return "Ano de fabricacao invalido";
             try{

               vei.setPlaca(placa);
               vei.setPro(pes);
               vei.setCidade(cidade);
               vei.setChassi(chassi);
               vei.setRenavam(renavam);
               vei.setTipoCarroceria(TipoCarroceria);
               vei.setAnoFabricacao(anoFabricacao);
               vei.setModelo(modelo);
               vei.setFabricante(fabricante);
               vei.setCor(cor);
               String query = queryAlteraVeiculo(vei);
               bd.Conectar();
               bd.insercao(query);
               bd.Desconetar();
               return "Alteração feita";
           }catch(SQLException ex){
                bd.Desconetar();
                return "Erro ao alterar no banco de dados";
            }catch (Exception ex) {
               return "Erro ao alterar os dados do veiculo";
           }


         }
         /*
          * **************************************************************************
          * ****************************** PROPRIETARIO ******************************
          * **************************************************************************
          */

         /* tipo ID=1, CNPJ =2, CPF =3, Nome = 4*/
         public static ArrayList <Pessoa> buscaProprietario(String chave, int tipo){
                ArrayList <Pessoa> pessoa = new ArrayList<Pessoa>();
                String query = ConsultaProprietario(chave,tipo);
                String dados[][];
                try{
                    bd.Conectar();
                    dados=bd.selecao(query);
                    bd.Desconetar();
                    for(int i=0;i<dados.length;i++){
                        Pessoa pes = new Pessoa(Uteis.transformaInt(dados[i][0]),dados[i][1],dados[i][2],dados[i][3],dados[i][4],dados[i][5],dados[i][6],dados[i][7],dados[i][8],dados[i][9]);
                        pessoa.add(pes);
                       }
                    return pessoa;
                }catch(Exception ex){
                     bd.Desconetar();
                    return pessoa;
                }
         }

         /*
          * ***************************************************************************
          * ******************************* SEGURO ************************************
          * ***************************************************************************
          */
         public static Seguro cadastroSeguro(String naturezaCarga,String especie,String quantidade,
                 String notaFiscal,String nome, String valorMercadoria, String peso,String CTRC, String valorICMS,
                 String valorSeguro,String outros,String total,String STRC,
                 String dataSeguro, Cliente remetente,Cliente destinatario, Veiculo veiculo, Motorista motorista,String vendedor){


                                           //String naturezaCarga, int quantidade, String notaFiscal, String especie, float valorMercadoria, String nome, float peso
             Mercadoria mercadoria = new Mercadoria(naturezaCarga, Uteis.transformaInt(quantidade), notaFiscal,especie,
                     Uteis.transformaFloat(valorMercadoria),nome,Uteis.transformaFloat(peso));
             Destinatario destin= new Destinatario(destinatario);
             Remetente remet = new Remetente(remetente);
             Data dataSeg = new Data(dataSeguro);
             Seguro seg = new Seguro(motorista, veiculo,funcLogado, destin,
                     remet, mercadoria, Uteis.transformaFloat(valorSeguro),Uteis.transformaFloat(valorICMS),CTRC,
                     Uteis.transformaFloat(outros),Uteis.transformaFloat(total),dataSeg,STRC,vendedor);
             return seg;
         }


         public static String removerSeguro(Seguro seg){
             String query = queryRemoveSeguro(seg);

             try{
             bd.Conectar();
             bd.insercao(query);
             bd.Desconetar();
             }catch(SQLException ex){
                 bd.Desconetar();
                 return "erro no banco";
             }
             return "cadastro efetuado";
         }

        public static String removerSeguro(Cliente_has_Seguro get) {
            String result = removerSeguro(get.getSeg());
            return result;
        }

   

         /*
          * ************************************* CLIENTE HAS SEGURO AKI ***********************************
          * ************************************************************************************************
          * ///////////////////////////////////////////////////////////////////////////////////////////////
          */


        public static String alterarSeguro(ArrayList<Cliente_has_Seguro> seg,String naturezaCarga,String especie,String valorMercadoria,String quantidade,
                 String notaFiscal, String CTRC, String valorICMS, String valorSeguro,String outros,String total,String mercadoria,String peso,String STRC,String dataSeguro,String pago, String vendedor){
                String result="";
                for(Cliente_has_Seguro s:seg){
                     s.getSeg().getMer().setNaturezaCarga(naturezaCarga);
                     s.getSeg().getMer().setEspecie(especie);
                     s.getSeg().getMer().setValorMercadoria(Uteis.transformaFloat(valorMercadoria));
                     s.getSeg().getMer().setQuantidade(Uteis.transformaInt(quantidade));
                     s.getSeg().getMer().setNotaFiscal(notaFiscal);
                     s.getSeg().setCTRC(CTRC);
                     s.getSeg().setValorICMS(Uteis.transformaFloat(valorICMS));
                     s.getSeg().setValorSeguro(Uteis.transformaFloat(valorSeguro));
                     s.getSeg().setOutros(Uteis.transformaFloat(outros));
                     s.getSeg().setTotal(Uteis.transformaFloat(total));
                     s.getSeg().getMer().setNome(mercadoria);
                     s.getSeg().getMer().setPeso(Uteis.transformaFloat(peso));
                     s.getSeg().setSTRC(STRC);
                     s.getSeg().setDataSeguro(new Data(dataSeguro));
                     s.getSeg().setVendedor(vendedor);
                 }
                 bd.Conectar();
                try {
                    bd.getConexao().setAutoCommit(false);

                 for(Cliente_has_Seguro s:seg)
                   result= bd.executeProcedureAlterarSeguro(s);
                 bd.getConexao().commit();
                 bd.getConexao().setAutoCommit(true);
                 } catch (SQLException ex) {
                        try {
                        bd.getConexao().rollback();
                        bd.getConexao().setAutoCommit(true);
                        return result;
                    } catch (SQLException ex1) {
                       ex1.printStackTrace();
                       bd.Desconetar();
                       return result;
                    }
                }
                bd.Desconetar();
             return result;
         }

         public static String cliente_has_Seguro(ArrayList <Cliente> cli, Seguro seg, ArrayList <Float> valorFatura,String pago){
             ArrayList <Cliente_has_Seguro> cliSeg = new ArrayList <Cliente_has_Seguro>();
             String query;
             float fatura = Uteis.transformaFloat(pago);

             for(int i=0;i<cli.size();i++){
                Cliente_has_Seguro cliSe = new Cliente_has_Seguro(cli.get(i), seg,valorFatura.get(i),0);
                cliSeg.add(cliSe);
             }
               MudaValor(fatura, cliSeg);
             try{

                 bd.Conectar();
                  bd.getConexao().setAutoCommit(false);
                 int id = bd.executeProcedureSeguro(seg);
                 if(id>0){
                     for(Cliente_has_Seguro c: cliSeg){
                         query = queryClientHasSeguro(c,id);
                         bd.insercao(query);
                     }
                     bd.getConexao().commit();
                     bd.getConexao().setAutoCommit(true);
                     bd.Desconetar();
                      return "Cadastro realizado com sucesso";
                 }

                 bd.Desconetar();
                 return "erro ao obter o id do banco";
             }catch(SQLException ex){
                    try {
                        bd.getConexao().rollback();
                        bd.getConexao().setAutoCommit(true);
                    } catch (SQLException ex1) {
                        bd.Desconetar();
                       ex1.printStackTrace();
                    }
                 bd.Desconetar();
                       return "erro no banco";
             }

         }


    public static ArrayList<Cliente_has_Seguro> buscarSegurosData(Cliente clie,String dataInicio,String dataFim){
        Data fim = new Data(dataFim);
        Data inicio = new Data(dataInicio);
        ArrayList <Cliente_has_Seguro> result = new ArrayList<Cliente_has_Seguro>();
        String  query = queryConsultaCliSeg(clie.getId(),inicio.formatoBanco(),fim.formatoBanco());
        result.addAll(buscarPeloCliente(query,clie));
        return result;

    }

    public static ArrayList<Cliente_has_Seguro> tenhoCliente(String chave,int tipo){
           ArrayList <Cliente_has_Seguro> result = new ArrayList<Cliente_has_Seguro>();
           ArrayList <Cliente> cli = new ArrayList<Cliente>();
           if(tipo!=1)
                cli.addAll(consultaCliente(chave,99));
           else
                cli.addAll(consultaCliente(chave,1));
          for(Cliente c:cli){
            String  query = queryConsultaCliSegSemData(c.getId());
              result.addAll(buscarPeloCliente(query,c));
          }
            return result;
    }
    
    public static void RemetenteDestinatario(String chave,ArrayList <Cliente> cli){
        String query;
        String dados[][];
        query = queryConsultaJuridico(chave,5);
        try{
                      dados = bd.selecao(query);
                      if(dados.length>0){
                           cli.addAll(montObjJuridico(dados));
                      }else{
                           query = queryConsultaFisico(chave,5);
                           dados = bd.selecao(query);
                           cli.addAll(montObjFisico(dados));
                         
                      }
        }catch(SQLException ex){}
    }

    public static ArrayList<Cliente_has_Seguro> buscarPeloCliente(String query,Cliente clie){
         ArrayList <Cliente_has_Seguro> result = new ArrayList<Cliente_has_Seguro>();
        ArrayList <Cliente> cli = new ArrayList<Cliente>();
        ArrayList <Motorista> mot = new ArrayList<Motorista>();
        ArrayList <Funcionario> func = new ArrayList<Funcionario>();
        ArrayList <Veiculo> vei = new ArrayList<Veiculo>();
        Seguro seg = null;
        String dados[][],funcionario[][];
        String dadosM[][],motorista[][];
        String dadosSc[][],veiculo[][];
         bd.Conectar();
          try{
                
                 dadosSc = bd.selecao(query);
                
              }catch(SQLException ex){
                   bd.Desconetar();
                  return result;
              }
             // idCliente,valorFatura,valorJaPago,idSeguro
             for(int j=0;j<dadosSc.length;j++){
                 query = queryConsultaSeguro(dadosSc[j][3],6);
                 try{
                 dados = bd.selecao(query);
                 for(int i=0;i<dados.length;i++){
                                       
                      RemetenteDestinatario(dados[i][1],cli);              
                      RemetenteDestinatario(dados[i][2],cli);
                      
                      query = queryConsultaMotorista(dados[i][3],1);                      
                      motorista = bd.selecao(query);
                      montObjMotorista(motorista,mot);
                      
                      query = queryConsultaFuncionario(dados[i][4],1);
                      funcionario = bd.selecao(query);
                      montObjFuncionario(funcionario,func);
                      
                      query = queryConsultaVeiculo(dados[i][5], 5);
                      veiculo = bd.selecao(query);
                      montObjVeiculo(veiculo,vei);
                      
                      query= queryConsultaMercadoria(dados[i][6]);                      
                      dadosM = bd.selecao(query);
             
                      //  int idMercadoria, String naturezaCarga, int quantidade,
                      // String notaFiscal, String especie, float valorMercadoria, String nome, float peso
                        Mercadoria mec = new Mercadoria(Uteis.transformaInt(dadosM[0][0]),dadosM[0][2],Uteis.transformaInt(dadosM[0][4]),dadosM[0][7],dadosM[0][5],Uteis.transformaFloat(dadosM[0][6]),dadosM[0][1],Uteis.transformaFloat(dadosM[0][3]));
                      Data date = new Data();
                      date.dataBanco(dados[i][12]);
                      Remetente re = new Remetente(cli.get(0).getId(),cli.get(0));
                      Destinatario des = new Destinatario(cli.get(1).getId(),cli.get(1));
                     // int idSeguro, Motorista mot, Veiculo veic, Funcionario func, Destinatario dest, Remetente rem, Mercadoria mer, float valorSeguro, float valorICMS, String CTRC, float outros, float total, Data dataSeguro, String STRC)
                      seg =new Seguro(Uteis.transformaInt(dados[i][0]),mot.get(0),vei.get(0),func.get(0),des,re,mec,Uteis.transformaFloat(dados[i][7]),Uteis.transformaFloat(dados[i][8]),dados[i][9],Uteis.transformaFloat(dados[i][10]),Uteis.transformaFloat(dados[i][11]),date,dados[i][13],dados[i][14]);
                      mot.clear();
                      func.clear();
                      vei.clear();
                      cli.clear();
                 }
                   }catch(SQLException ex){
                         bd.Desconetar();
                         return result;
                   }
                 if(seg!=null){
                    Cliente_has_Seguro cs = new Cliente_has_Seguro(clie,seg,Uteis.transformaFloat(dadosSc[j][1]),Uteis.transformaFloat(dadosSc[j][2]));
                    result.add(cs);
                 }else{
                     bd.Desconetar();
                     return result;
                 }

              }
              bd.Desconetar();
              return result;
    }



         public static ArrayList<Cliente_has_Seguro> buscarSeguros(String chave, int tipo){
             ArrayList <Cliente_has_Seguro> result = new ArrayList<Cliente_has_Seguro>();
             String query;

             String multiplosJuridicos = "",multiplosFisicos="",mult[][],temp[][];

             if(tipo == 3 || tipo ==4 || tipo ==5){
                multiplosJuridicos =queryVariasBuscasSeguroJuridicos(chave);
                multiplosFisicos = queryVariasBuscasSeguroFisico(chave);
             }/*
              *   query = "Select idSeguro,Remetente,Destinatario,Motorista_PessoaFisica_Pessoa_id,Funcionario_PessoaFisica_Pessoa_id,";
                  query += "Veiculo_idVeiculo,Mercadoria_idMercadoria,valorSeguro,valorICMS,CTRC,outros,total,dataSeguro,strc ";
              */
           
            if(tipo ==3 || tipo==4){
                try {
                 bd.Conectar();
                    mult = bd.selecao(multiplosJuridicos);
                    temp = bd.selecao(multiplosFisicos);
                    bd.Desconetar();
                    for(int i=0;i<mult.length;i++)
                        result.addAll(buscaPeloSeguro(mult[i][0],tipo));
                    for(int i=0;i<temp.length;i++)
                        result.addAll(buscaPeloSeguro(temp[i][0],tipo));
                    
                } catch (SQLException ex) {
                    bd.Desconetar();
                    return result;
                }
             }else if (tipo==5){
                 result.addAll(tenhoCliente(chave,99));
             }else
                 result.addAll(buscaPeloSeguro(chave,tipo));

             return result;
         }

         public static ArrayList<Cliente_has_Seguro> buscaPeloSeguro(String chave,int tipo){
             ArrayList <Cliente_has_Seguro> result = new ArrayList<Cliente_has_Seguro>();
             ArrayList <Motorista> mot = new ArrayList<Motorista>();
             ArrayList <Funcionario> func = new ArrayList<Funcionario>();
             ArrayList <Cliente> cli = new ArrayList<Cliente>();
             ArrayList <Veiculo> vei = new ArrayList<Veiculo>();
            String dados[][],funcionario[][];
            String dadosM[][],motorista[][];
            String dadosSc[][],veiculo[][];
             String query;
             query = queryConsultaSeguro(chave,tipo);
              bd.Conectar();
             try{
                 dados = bd.selecao(query);
                 
                 for(int i=0;i<dados.length;i++){
                      
                      RemetenteDestinatario(dados[i][1],cli);              
                      RemetenteDestinatario(dados[i][2],cli);
                      
                      query = queryConsultaMotorista(dados[i][3],1);                      
                      motorista = bd.selecao(query);
                      montObjMotorista(motorista,mot);
                      
                      query = queryConsultaFuncionario(dados[i][4],1);
                      funcionario = bd.selecao(query);
                      montObjFuncionario(funcionario,func);
                      
                      query = queryConsultaVeiculo(dados[i][5], 5);
                      veiculo = bd.selecao(query);
                      montObjVeiculo(veiculo,vei);
                      
                      query= queryConsultaMercadoria(dados[i][6]);                      
                      dadosM = bd.selecao(query);
                     
                      /*int idMercadoria, String naturezaCarga, int quantidade,
                       String notaFiscal, String especie, float valorMercadoria, String nome, float peso*/
                      Mercadoria mec = new Mercadoria(Uteis.transformaInt(dadosM[0][0]),dadosM[0][2],Uteis.transformaInt(dadosM[0][4]),dadosM[0][7],dadosM[0][5],Uteis.transformaFloat(dadosM[0][6]),dadosM[0][1],Uteis.transformaFloat(dadosM[0][3]));
                      Data date = new Data();
                      date.dataBanco(dados[i][12]);
                      Remetente re = new Remetente(cli.get(0).getId(),cli.get(0));
                      Destinatario des = new Destinatario(cli.get(1).getId(),cli.get(1));
                      /*int idSeguro, Motorista mot, Veiculo veic, Funcionario func, Destinatario dest, Remetente rem, Mercadoria mer, float valorSeguro, float valorICMS, String CTRC, float outros, float total, Data dataSeguro, String STRC)*/
                      Seguro seg = new Seguro(Uteis.transformaInt(dados[i][0]),mot.get(0),vei.get(0),func.get(0),des,re,mec,Uteis.transformaFloat(dados[i][7]),Uteis.transformaFloat(dados[i][8]),dados[i][9],Uteis.transformaFloat(dados[i][10]),Uteis.transformaFloat(dados[i][11]),date,dados[i][13],dados[i][14]);
                      cli.clear();
                      mot.clear();
                      func.clear();
                      vei.clear();
                      query = queryConsultaCliSeg(seg.getIdSeguro());
                      dadosSc = bd.selecao(query);
                      // idCliente,valorFatura,valorJaPago
                      for(int j=0;j<dadosSc.length;j++){
                          cli.addAll(consultaCliente(dadosSc[j][0], 5));
                          Cliente_has_Seguro cs = new Cliente_has_Seguro(cli.get(0),seg,Uteis.transformaFloat(dadosSc[j][1]),Uteis.transformaFloat(dadosSc[j][2]));
                      
                          result.add(cs);
                          cli.clear();
                      }
                      cli.clear();
                 }
                 bd.Desconetar();
                 return result;
             }catch(SQLException ex){
                  bd.Desconetar();
                 return result;
             }
         }

         /*
          * ******************************************************************************
          * ******************************* COMPROVANTE **********************************
          * ******************************************************************************
          *      ALGUNS METODOS NAO FORAM IMPLEMENTADOS POIS NAO HAVIA NECESSIDADE
          */

         public static Comprovante cadastroComprovante(Cliente_has_Seguro seg,String dataComprovante,String infoComplementares,String segurado){

             Data dataComprovante2 = new Data(dataComprovante);
                try {

                    Comprovante comp = new Comprovante(seg,dataComprovante2,infoComplementares,segurado);
                    return comp;
                } catch (Exception ex) {
                    return null;
                }
         }

  
          ////////////////////////////////////////
         ///////////////LOGIN////////////////////
         ////////////////////////////////////////

         public static boolean login(String usuario, String senha){
             ArrayList<Funcionario> funcionarios = Controlador.consultarFuncionario("", 3);
             for(Funcionario f:funcionarios)
                 if(usuario.equals(f.getLogin()) && senha.equals(f.getSenha())){
                     funcLogado = f;
                     return true;
                 }
             return false;
         }

         /*
          * ******************************************************************************
          * ******************************* CONTA A PAGAR ********************************
          * ******************************************************************************
          */
         public static String cadastroConta(Funcionario func, String emitente, String tipoConta,
                String documento, String emissao, String localCobranca, ArrayList<Parcela>Parcelas){
                String  query;
                Data emissao2 = new Data(emissao);
                bd.Conectar();
                try {
                    TipoConta tipo = new TipoConta(tipoConta);
                    ContaPagar contP = new ContaPagar(documento,emissao2,localCobranca,tipo,func,emitente);

                    query = queryContaPagarInsert(contP);
                   
                    int[] id = bd.executeStoredProcedure(tipo,contP);
                    if(id[0]<=0 || id[1]<=0)
                        return "Erro ao cadastrar a conta no banco";
                    contP.setIdContaPagar(id[0]); //id[0] == idContaApagar
                    contP.setIdConta(id[1]); //id[1] == idConta
                    for(Parcela p:Parcelas){
                        p.setConta(contP);
                    }
                       for(Parcela p:Parcelas){
                        Parcela parc = new Parcela(p.getVencimento(),p.getValor(),p.getNumParcela(),p.getConta());
                        query = queryParcelasInsert(parc);
                        bd.insercao(query);
                    }
                    bd.Desconetar();
                    return "Cadastro realizado com sucesso";
                } catch (Exception ex) {
                    bd.Desconetar();
                    return "Erro no cadastro";
                }
         }
         public static String removerParcela(Parcela contP){
             try{
                String query = queryRemoveParcelas(contP.getIdParcela());
                bd.Conectar();
                bd.insercao(query);
                bd.Desconetar();

                return "Remoção feita";
             }catch(Exception ex){
                bd.Conectar();
                return "erro ao remover";
             }
         }


         public static ArrayList<ContaPagar> buscaContaPagar(String chave, int tip){
             ArrayList <ContaPagar> contapagar = new ArrayList<ContaPagar>();
             ArrayList<Funcionario> func = new ArrayList<Funcionario>();
                String query = queryConsultaContaPagar(chave,tip);
                String dados[][];
            try {
                bd.Conectar();
                dados = bd.selecao(query);
                bd.Desconetar();
                for(int i=0;i<dados.length;i++){
                    try {
                        func.addAll(consultarFuncionario(dados[i][0], 1));
                            Data emissao = new Data();
                            emissao.dataBanco(dados[i][4]);
                            TipoConta tipo = new TipoConta(Uteis.transformaInt(dados[i][8]),dados[i][7]);

                                             // int idConta, String documento, Data emissao, Data vencimento, String localCobranca, TipoConta tipo, Funcionario func, String emitente, int idContaPagar)
                            ContaPagar contP = new ContaPagar(Uteis.transformaInt(dados[i][2]),dados[i][3],emissao,dados[i][5],tipo,func.get(0),dados[i][1],Uteis.transformaInt(dados[i][8]));
                            contapagar.add(contP);
                        func.clear();

                    } catch (Exception ex) {  }
                }
             } catch (SQLException ex) {
                bd.Desconetar();
                return null;
             }
             return contapagar;
         }

         public static ArrayList<Parcela> buscaParcelaF(String chave, int tipo){
             ArrayList <Funcionario> f = new ArrayList<Funcionario>();
             ArrayList <Parcela> parcela = new ArrayList<Parcela>();
             f.addAll(consultarFuncionario(chave, 2));
             if(f.size()==1)
                parcela.addAll(buscaParcela(String.format("%d",f.get(0).getIdPessoaFisica()), 4));
             return parcela;
         }

       public static ArrayList<Parcela> buscaParcela(String chave, int tipo){
             ArrayList <Parcela> parcela = new ArrayList<Parcela>();
             ArrayList <ContaPagar> contP = new ArrayList<ContaPagar>();
             String query="";

                query = queryConsultaParcela(chave,tipo);
                String dados[][];
                int posicao=0;

            try {
                bd.Conectar();
                dados = bd.selecao(query);
                bd.Desconetar();
                for(int i=0;i<dados.length;i++){
                    try {
                            Data vencimento = new Data();
                            vencimento.dataBanco(dados[i][3]);

                            contP.addAll(buscaContaPagar(dados[i][1],4));

                            for(int j=0; j<contP.size(); j++){
                                if(contP.get(j).getIdConta() == Uteis.transformaInt(dados[i][1])){
                                    posicao = j;
                                    break;
                                }
                            }

                        Parcela parc = new Parcela(Uteis.transformaInt(dados[i][0]), vencimento, Uteis.transformaFloat(dados[i][5]), Uteis.transformaInt(dados[i][4]), contP.get(posicao));
                       parcela.add(parc);
                    } catch (Exception ex) {  }
                }
             } catch (SQLException ex) {
                return null;
             }
             return parcela;
         }

       public static String alterarContaPagar(Parcela parce, String emitente, String tipoConta,
                 String documento, String emissao, String localCobranca){
           String query;
            try{
               parce.getConta().getTipo().setTipoConta(tipoConta);
               Data emissao2 = new Data(emissao);
               parce.getConta().setDocumento(documento);
               parce.getConta().setEmissao(emissao2);
               parce.getConta().setLocalCobranca(localCobranca);
               parce.getConta().setEmitente(emitente);

                  
               query = queryParcelasAlterar(parce);
               bd.Conectar();
               bd.getConexao().setAutoCommit(false);
               bd.insercao(query);
               query = queryContaPagarAlterar(parce.getConta());
               bd.insercao(query);
               bd.getConexao().setAutoCommit(true);
               bd.Desconetar();
               return "alteração realizada";
           }catch(Exception ex){
                   try {
                        bd.getConexao().rollback();
                        bd.getConexao().setAutoCommit(true);
                    } catch (SQLException ex1) {
                       ex1.printStackTrace();
                    }
                 bd.Desconetar();
               return "Erro ao alterar os dados da conta a pagar";
           }

         }

         public static Parcela parcelas(String vencimento, String valor,String numParcela){
             Data date = new Data(vencimento);
             Parcela p = new Parcela(date,Uteis.transformaFloat(valor),Uteis.transformaInt(numParcela));
             return p;
         }

         public static ArrayList<Cliente_has_Seguro> segurosDoDia(String data){
             ArrayList<Cliente_has_Seguro> cli = new ArrayList<Cliente_has_Seguro> ();
             String dados[][];
             String dadosNrepetidos[];
             String query;
             query = querySegDia(data);
             try{
                 bd.Conectar();
                 dados = bd.selecao(query);
                 dadosNrepetidos=Uteis.soPodeHaverUm(dados);
                 for(String s:dadosNrepetidos){
                  cli.addAll(buscarSeguros(s,6));
                 }
                 bd.Desconetar();
             }catch(SQLException ex){
                 return cli;
             }
             return cli;
         }

         public static boolean BuscaEmpresa(int id){
             String query;
             String dados[][];
             try{
                 query = queryEmp(id);
                 bd.Conectar();
                 dados = bd.selecao(query);
                 bd.Desconetar();
                 for(int i=0;i<dados.length;i++){
                     //query  nome,fantasia,foneFixo,celular,CNPJ,IE,endereco,CEP,cidade,UF,bairro
                     //String CnpjEmp, String razao, String IE, String fantasia, String endereco, String cep, String municipio, String contato, String bairro, String telefone, String celular,String estado)
                      empresa = new Emp(dados[i][0],dados[i][1],dados[i][2],dados[i][3],dados[i][4],dados[i][5],dados[i][6],dados[i][7],dados[i][8],dados[i][9],dados[i][10],dados[i][11]);
                 }
                 if(empresa ==null)
                     return false;
             }catch(SQLException ex){
                 return false;
             }
             return true;
         }
         public static boolean validaCPF(String cpf){
             if(cpf.equals(""))
                 return true;
             cpf = Uteis.manipulaCPF(cpf);
             String query = queryValidaCPF(cpf);
             String query2=queryBuscaCPF(cpf);
             String dados[][],dados2[][];
             try{
                 bd.Conectar();
                 dados = bd.selecao(query);
                 dados2=bd.selecao(query2);
                 bd.Desconetar();
                 if(Uteis.transformaInt(dados[0][0])==1 && dados2.length==0)
                     return true;
                 else
                     return false;
             }catch(SQLException ex){
                return true;
            }
        }
         public static boolean validaCNPJ(String cnpj){
             if(cnpj.equals(""))
                 return true;
             cnpj = Uteis.manipulaCNPJ(cnpj);
             String query = queryValidaCNPJ(cnpj);
             String query2 =queryBuscaCNPJ(cnpj);
             String dados[][];
             String dados2[][];
             try{
                 bd.Conectar();
                 dados= bd.selecao(query);
                 dados2 = bd.selecao(query2);
                 bd.Desconetar();
                 if(Uteis.transformaInt(dados[0][0])==1 && dados2.length==0)
                     return true;
                 else
                     return false;
             }catch(SQLException ex){
                 return false;
             }
         }
         public static boolean validaSTRC(String STRC){
             if(STRC.equals(""))
                 return true;
             String query = queryValidaSTRC(STRC);
             String dados[][];
             try{
                 bd.Conectar();
                 dados = bd.selecao(query);
                 bd.Desconetar();
                 if(dados.length>0)
                     return true;
             }catch(SQLException ex){
                 return true;
             }
             return false;
         }


         public static String [] InserirNovaMercadoria(String text) throws SQLException {
             String resultado [] = null;
             String dados[][];
             String query;
              bd.Conectar();
             if(!text.equals("")){
                query = queryNovaMercadoria(text);    
                bd.insercao(query);
             }
             query = querySelecionarMercadorias();
             dados = bd.selecao(query);
             bd.Desconetar();
             resultado  = new String[dados.length];
             for(int i=0 ;i<dados.length;i++)
                    resultado[i]=dados[i][0];
             return resultado;

        }

    public static String[] InserirNovaConta(String text) throws SQLException {
         String resultado [] = null;
             String dados[][];
             String query;
                 bd.Conectar();
             if(!text.equals("")){
                query = queryNovaConta(text);
                bd.insercao(query);
                
             }
             query = querySelecionarNovaConta();
             dados = bd.selecao(query);
             bd.Desconetar();
             resultado  = new String[dados.length];
             for(int i=0 ;i<dados.length;i++)
                    resultado[i]=dados[i][0];
             return resultado;
    }

        /*
         *  Controlador.CadastrarEmpresa(nome.getText(),CEP.getText(),IE.getText(),CNPJ.getText(),Uf.getItemAt(Uf.getSelectedIndex()).toString(),nomeFantasia.getText(),
                endereco.getAccessibleContext(),telefoneCelular.getText(),telefoneFixo.getText(),cidade.getText(),bairro.getText());
         */
    public static String CadastrarEmpresa(String nome, String CEP, String IE, String CNPJ, String Uf, String nomeFantasia,
            String endereco, String telefoneCelular, String telefoneFixo, String cidade, String bairro, String contato) {

        /*String CnpjEmp, String razao, String IE, String fantasia, String endereco, String cep, String municipio, String contato, String bairro, String telefone, String celular,String estado)*/
            Emp emp = new Emp(CNPJ,nome,IE,nomeFantasia,endereco,CEP,cidade,contato,bairro,telefoneFixo,telefoneCelular,Uf);
            String query = queryInserirEmpresa(emp);
            bd.Conectar();
            try{
                bd.insercao(query);
                bd.Desconetar();
                Controlador.empresa = emp;
            }catch(SQLException ex){
                 bd.Desconetar();
                return  ex.getMessage();
            }
            return "cadastro feito com sucesso";
    }


    public static String alterarEmpresa(Emp emp, String nome, String CEP, String IE, String CNPJ, String Uf, String nomeFantasia,
            String endereco, String telefoneCelular, String telefoneFixo, String cidade, String bairro, String contato) {
            emp.setBairro(bairro);
            emp.setCelular(telefoneCelular);
            emp.setCep(CEP);
            emp.setCnpjEmp(CNPJ);
            emp.setContato(contato);
            emp.setEndereco(endereco);
            emp.setEstado(Uf);
            emp.setFantasia(nomeFantasia);
            emp.setIE(IE);
            emp.setMunicipio(cidade);
            emp.setRazao(nome);
            emp.setTelefone(telefoneFixo);
            String query = updateEmpresa(emp);
            try{
                bd.Conectar();
                bd.insercao(query);
                bd.Desconetar();
                Controlador.empresa = emp;
                return "alteracao da empresa feita";
            }catch(SQLException ex){
                 bd.Desconetar();
                return ex.getMessage();
            }
    }

    public static void MudaValor(float fatura,ArrayList <Cliente_has_Seguro> s){
         float sobra=0;
            for (Cliente_has_Seguro seg: s){
                if(fatura>0){
                    sobra = fatura - (seg.getValorFatura()-seg.getValorJaPago());
                    if(sobra>0)
                        seg.setValorJaPago(seg.getValorJaPago()+(fatura - sobra));
                    else
                        seg.setValorJaPago(seg.getValorJaPago()+(fatura));
                    fatura -= (fatura - sobra);
                }else
                    break;
                
            }
    }
    
     public static String faturar(ArrayList <Cliente_has_Seguro> s, String faturar) {
            
         float fatura = Uteis.transformaFloat(Uteis.removePonto(faturar));
            /*
             * como faturar os seguros
             * sobra = fatura - (ValorDaFatura-ValorJaPago)
               valorJaPago += fatura - sobra;
               fatura -= (fatura - sobra);
             */
           MudaValor(fatura, s);
            
            String result="Valor Faturado!";
            bd.Conectar();
                try {
                    bd.getConexao().setAutoCommit(false);
                  for (Cliente_has_Seguro seg: s){
                    bd.executeProcedureAlterarSeguro(seg);
                  }
                 bd.getConexao().commit();
                 bd.getConexao().setAutoCommit(true);
                 } catch (SQLException ex) {
                        try {
                        bd.getConexao().rollback();
                        bd.getConexao().setAutoCommit(true);
                        return "valor Não foi faturado";
                    } catch (SQLException ex1) {
                       bd.Desconetar();
                       ex1.printStackTrace();
                       return "valor Não foi faturado";
                    }
                }
                bd.Desconetar();
                return result;
    }

     public static ChartPanel graficoEmpresas(String inicio,String Fim,int quantidade,int tipo)throws Exception{
           GerarGrafico g = new GerarGrafico();
           String [][]dadosFisico=null,dadosJuridico=null;
           String query1,query2;
           try{
               query1 = obtemVendas1(inicio,Fim,tipo);
               query2= obtemVendas2(inicio,Fim,tipo);
               bd.Conectar();
               dadosFisico = bd.selecao(query1);
               dadosJuridico = bd.selecao(query2);
               bd.Desconetar();
         }catch(SQLException ex){
            bd.Desconetar();
            return null;
         }
           g.VendasXEmpresas(dadosFisico, dadosJuridico, quantidade);
           return g.getGrafico();
     }
      public static ChartPanel graficoVendasMes(String inicio,String Fim)throws Exception{
           GerarGrafico g = new GerarGrafico();
           String [][]dados=null;
           String query1;
           try{
               query1 = vendasMes(inicio,Fim);
               bd.Conectar();
               dados = bd.selecao(query1);
               bd.Desconetar();
         }catch(SQLException ex){
            bd.Desconetar();
            return null;
         }
           g.Vendas(dados);
           return g.getGrafico();
     }

        public static String CPFouCNPJproprietario(int id) {
        String query;
        String [][]dados;
        try{
            query = queryBuscaCPF(id);
            bd.Conectar();
            dados = bd.selecao(query);
            if(dados.length>0)
                return dados[0][0];
            query = queryBuscaCNPJ(id);
            dados = bd.selecao(query);
            bd.Desconetar();
            if(dados.length>0)
                return dados[0][0];

        }catch(SQLException ex){
            bd.Desconetar();
            return null;
        }
        return "----";
    }
    public static boolean VerificaPlaca(String text) {
        String query,dados[][];
        query = queryPlaca(text);
        try{
           bd.Conectar();
           dados = bd.selecao(query);
           bd.Desconetar();
           if(dados.length>0)
               return true;
       }catch(SQLException ex){
           bd.Desconetar();
           return true;
       }
       return false;
    }

    public static ArrayList<Motorista> validadeCNH(){
        String query = queryDataCNH();
        String dados[][];
        ArrayList <Motorista> m = new ArrayList<Motorista>();
        try{
            bd.Conectar();
            dados = bd.selecao(query);
            bd.Desconetar();
            montObjMotorista(dados, m);
            return m;
        }catch(SQLException ex){
            bd.Desconetar();
            return null;
        }
    }

    public static String [][] contasAreceber(){
            String query = queryContaReceber();
            String dados[][];
            try{
                    bd.Conectar();
                    dados = bd.selecao(query);
                    bd.Desconetar();
                    return dados;
                }catch(SQLException ex){
                    bd.Desconetar();
                    return null;
                }
   }

    public static String menorData(){
            String query = queryMenorData();
            String dados[][];
            Data date = new Data();
            date.dataBanco(Uteis.DataCorrente());
            try{
                bd.Conectar();
                dados = bd.selecao(query);
                bd.Desconetar();
                if(dados.length==1){
                    date.dataBanco(dados[0][0]);
                    return date.Formata_Data();
                }else{
                    return date.Formata_Data();
                }
            }catch(SQLException ex){
                bd.Desconetar();
                return date.Formata_Data();
            }
    }
    public static String somaRTFC(ArrayList <Cliente_has_Seguro> seg){
        String origem="",destino="";
        String dados[][];
        float temp=0;
        String query;
        ArrayList<RTFC> rtfc = new ArrayList<RTFC>();
        try{
             query=queryRTFC();
             bd.Conectar();
             dados = bd.selecao(query);
             bd.Desconetar();
             for(int i=0;i<dados.length;i++){
                 rtfc.add(new RTFC(Uteis.transformaFloat(dados[i][0]),dados[i][1],dados[i][2]));
             }
            for(Cliente_has_Seguro s: seg){
                if(s.getSeg().getRem().getCli() instanceof Fisico){
                    Fisico f = (Fisico)s.getSeg().getRem().getCli();
                    origem = f.getPessoa().getEstado();
                }else if(s.getSeg().getRem().getCli() instanceof Juridico){
                    Juridico j = (Juridico)s.getSeg().getRem().getCli();
                    origem = j.getPessoa().getEstado();
                }
                if(s.getSeg().getDest().getCli() instanceof Fisico){
                    Fisico f = (Fisico)s.getSeg().getDest().getCli();
                    destino = f.getPessoa().getEstado();
                }else if(s.getSeg().getDest().getCli() instanceof Juridico){
                    Juridico j = (Juridico)s.getSeg().getDest().getCli();
                    destino = j.getPessoa().getEstado();
                }
                boolean achou=false;
                   for(int i=0;i<rtfc.size();i++){
                       if(rtfc.get(i).getOrigem().equals(origem) && rtfc.get(i).getDestino().equals(destino)){
                            temp += s.getSeg().getValorSeguro()*rtfc.get(i).getTaxa();
                            achou = true;
                            break;
                       }
                    }
                if(!achou){
                    return "erro ao fazer o calculo";
                }
            }
                return Uteis.Moeda(temp);
            }catch(SQLException ex){
                bd.Desconetar();
                return "erro ao fazer o calculo";
            }
    }
     public static ChartPanel VendasFuncionario(String inicio, String Fim)throws Exception {
           GerarGrafico g = new GerarGrafico();
           String [][]dados=null;
           String query1;

           try{
               query1 = queryVendasFunc(inicio,Fim);
               bd.Conectar();
               dados = bd.selecao(query1);
               bd.Desconetar();
         }catch(SQLException ex){
            bd.Desconetar();
            return null;
         }
           g.Funcionario(dados);
           return g.getGrafico();
    }

     public static ChartPanel Balanco(String data)throws Exception{
           GerarGrafico g = new GerarGrafico();
           String [][]dados=null,dados1=null;
           String query1,query2;
            float result=0;
           String []dadosGrafico = new String [3];
           try{
               query1 = queryBalancoSeguros(data);
               query2 = queryBalancoConta(data);
               bd.Conectar();
               dados = bd.selecao(query1);
               dados1 = bd.selecao(query2);
               bd.Desconetar();
         }catch(SQLException ex){
            return null;
         }
           if(dados[0][0]!=null){
           dadosGrafico[0]=dados[0][0];
           result +=Uteis.transformaFloat(dados[0][0]);
           }else
               dadosGrafico[0]="0.00";
           if(dados1[0][0]!=null){
           dadosGrafico[1]=dados1[0][0];
           result -= Uteis.transformaFloat(dados1[0][0]);
           }else
               dadosGrafico[1]="0.00";
            dadosGrafico[2]=Uteis.Num(result);
           g.Balanco(dadosGrafico);
           return g.getGrafico();
    }

     public static String altCaixa(Funcionario f){
         try{
               bd.Conectar();
               String query = queryFuncionarioAlterar(f);
               bd.insercao(query);
               bd.Desconetar();
               return "alteração feita";
         }catch(SQLException ex){
             return "erro ao alterar";
         }
     }
         /*
          * ***********************************************************************************************
          * ***********************************************************************************************
          * ********************************* QUERYS MANOLO ***********************************************
          * ****************************** WELCOME TO THE JUNGLE ******************************************
          * ***********************************************************************************************
          * ***********************************************************************************************
          */


         public static String queryMotoristaInsert(Motorista mot){
             String query;
             query = "call inserirMotorista('"+mot.getNome()+"','"+mot.getTelefone()+"','"+mot.getEndereco()+"','"+mot.getCEP()+"','";
             query += mot.getNumEnd()+"','"+mot.getBairro()+"','"+mot.getEstado()+"','"+mot.getCidade()+"','"+mot.getCPF()+"','"+mot.getUfRG()+"','";
             query += mot.getRG()+"','"+mot.getOrgExRG()+"','"+mot.getCNH()+"','"+mot.getCategoriaCNH()+"','"+mot.getNomePai()+"','"+mot.getNomeMae()+"','";
             query += mot.getObs()+"','"+mot.getValidadeCNH().formatoBanco()+"','"+mot.getReferenciaPessoal()+"','"+mot.getTelefoneReferencia();
             query += "','"+mot.getCelular()+"','"+mot.getDataNascimento().formatoBanco()+"','"+mot.getApelido()+"','"+mot.getComplemento()+"',@erro)";
             return query;
         }

         public static String queryMotoristaAltera(Motorista mot){
             String query ="call alterarMotorista("+mot.getId()+",'"+mot.getNome()+"','"+mot.getTelefone()+"','"+mot.getEndereco()+"','"+mot.getCEP()+"','";
             query += mot.getNumEnd()+"','"+mot.getBairro()+"','"+mot.getEstado()+"','"+mot.getCidade()+"','"+mot.getCPF()+"','"+mot.getUfRG()+"','"+mot.getRG()+"','"+mot.getOrgExRG()+"','"+mot.getCNH()+"','";
             query += mot.getCategoriaCNH()+"','"+mot.getNomePai()+"','"+mot.getNomeMae()+"','"+mot.getObs()+"','"+mot.getValidadeCNH().formatoBanco()+"','"+mot.getReferenciaPessoal()+"','"+mot.getTelefoneReferencia()+"','"+mot.getCelular()+"','";
             query += mot.getDataNascimento().formatoBanco()+"','"+mot.getApelido()+"','"+mot.getComplemento()+"',@erro)";
             return query;
         }

         public static String queryConsultaMotorista(String chave, int tipo){
             String query;
             query = "Select nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,id,";
             query +="idPessoaFisica,CPF,ufRG,RG,orgExRG,";
             query +="CNH,categoriaCNH,nomePai,nomeMae,obs,validadeCNH,referenciaPessoal,telefoneReferencia,celular,dataNascimento,apelido,complemento ";
             query+= "from Motorista as m, Pessoa as p, PessoaFisica as pf ";
             if(tipo == 1){
                query+= "where m.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND (pf.idPessoaFisica="+chave+") ORDER BY nome;";
             } else if(tipo == 2){
                    query+= "where m.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND (pf.CPF like '"+chave+"%') ORDER BY nome;";
                } else{
                    query+= "where m.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND (p.nome like '"+chave+"%' OR m.apelido like '"+chave+"%') ORDER BY nome;";
                }
             return query;
         }

         public static String queryRemoveMotorista(Motorista mot){
             String query = "DELETE FROM Pessoa where id ='"+mot.getId()+"';";
             return query;
         }
         public static String queryFuncionarioInsert(Funcionario func){
             String query;
             query = "call inserirFuncionario('"+func.getNome()+"','"+func.getTelefone()+"','"+func.getEndereco()+"','";
             query +=   func.getCEP()+"','"+func.getNumEnd()+"','"+func.getBairro()+"','"+func.getEstado()+"','"+func.getCidade()+"','"+func.getCPF()+"','";
             query +=   func.getUfRG()+"','"+func.getRG()+"','"+func.getOrgExRG()+"','"+func.getLogin()+"','"+func.getSenha()+"','"+func.getCelular()+"','"+func.getDataNascimento().formatoBanco()+"',"+func.getNivelAcesso()+","+func.getValorCaixa()+",'"+func.getComplemento()+"',@erro);";
             return query;
         }
         public static String queryFuncionarioAlterar(Funcionario func){
             String query;
             query = "call alterarFuncionario("+func.getId()+",'"+func.getNome()+"','"+func.getTelefone()+"','"+func.getEndereco()+"','";
             query +=   func.getCEP()+"','"+func.getNumEnd()+"','"+func.getBairro()+"','"+func.getEstado()+"','"+func.getCidade()+"','"+func.getCPF()+"','";
             query +=   func.getUfRG()+"','"+func.getRG()+"','"+func.getOrgExRG()+"','"+func.getLogin()+"','"+func.getSenha()+"','"+func.getCelular()+"','"+func.getDataNascimento().formatoBanco()+"',"+func.getNivelAcesso()+","+func.getValorCaixa()+",'"+func.getComplemento()+"',@erro);";
            // System.out.println(query);
             return query;
         }
         public static String queryConsultaFuncionario(String chave, int tipo){
             String query;
             query = "Select nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,id,";
             query +="idPessoaFisica,CPF,ufRG,RG,orgExRG,";
             query +="login,senha,celular,dataNascimento,nivelAcesso,valorCaixa,complemento ";
             query+= "from Funcionario as f, Pessoa as p, PessoaFisica as pf ";
             if(tipo == 1){
                query+= "where f.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND (pf.idPessoaFisica="+chave+") ORDER BY nome;";
             } else {
                if(tipo == 2){
                    query+= "where f.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND (pf.CPF like '"+chave+"%') ORDER BY nome;";
                } else{
                    query+= "where f.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND (p.nome like '"+chave+"%') ORDER BY nome;";
                }
             }
             return query;
         }

         public static String queryRemoveFuncionario(Funcionario func){
             String query = "DELETE FROM Pessoa where id ='"+func.getId()+"';";
             return query;
         }

         public static String queryFisicoInsert(Fisico fis){
             String query;
             query = "call inserirClienteFisico('"+fis.getPessoa().getNome()+"','"+fis.getPessoa().getTelefone()+"','"+fis.getPessoa().getEndereco()+"','";
             query += fis.getPessoa().getCEP()+"','"+fis.getPessoa().getNumEnd()+"','"+fis.getPessoa().getBairro()+"','"+fis.getPessoa().getEstado()+"','";
             query += fis.getPessoa().getCidade()+"','"+fis.getPessoa().getCPF()+"','";
             query += fis.getPessoa().getUfRG()+"','"+fis.getPessoa().getRG()+"','"+fis.getPessoa().getOrgExRG()+"','"+fis.getTelFax()+"','"+fis.getEmail()+"','";
             query+= fis.getOutrasInf()+"',"+fis.getTaxa()+","+fis.getValorFixo()+","+fis.getDesconto()+",'"+fis.getNomeFaturante()+"','"+fis.getPessoa().getComplemento()+"', @erro);";
             return query;
         }

         public static String queryFisicoAlterar(Fisico fis){
             String query;
             query = "call alterarClienteFisico("+fis.getPessoa().getId()+","+fis.getId()+",'"+fis.getPessoa().getNome()+"','"+fis.getPessoa().getTelefone()+"','"+fis.getPessoa().getEndereco()+"','";
             query += fis.getPessoa().getCEP()+"','"+fis.getPessoa().getNumEnd()+"','"+fis.getPessoa().getBairro()+"','"+fis.getPessoa().getEstado()+"','";
             query += fis.getPessoa().getCidade()+"','"+fis.getPessoa().getCPF()+"','";
             query += fis.getPessoa().getUfRG()+"','"+fis.getPessoa().getRG()+"','"+fis.getPessoa().getOrgExRG()+"','"+fis.getTelFax()+"','"+fis.getEmail()+"','";
             query+= fis.getOutrasInf()+"',"+fis.getTaxa()+","+fis.getValorFixo()+","+fis.getDesconto()+",'"+fis.getNomeFaturante()+"','"+fis.getPessoa().getComplemento()+"', @erro);";
             return query;
         }

         public static String queryConsultaFisico(String chave, int tipo){
             String query;
             query = "Select nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,";
             query +="idCliente,CPF,ufRG,RG,orgExRG,";
             query +="telFax,email,outrasInf,taxa,valorFixo,desconto,";
             query +="id,idPessoaFisica,nomeFaturante,complemento ";
             query+= "from ClienteFisico as cf, Pessoa as p, PessoaFisica as pf, Cliente as c ";
             if(tipo == 1){
                query+= "where cf.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND cf.Cliente_idCliente = c.idCliente AND (pf.idPessoaFisica="+chave+") ORDER BY nome;";
             } else  if(tipo == 2){
                    query+= "where cf.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND cf.Cliente_idCliente = c.idCliente AND (pf.CPF like '"+chave+"%') ORDER BY nome;";
             }else if (tipo ==5){
                    query+= "where cf.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND cf.Cliente_idCliente = c.idCliente AND (cf.Cliente_idCliente="+chave+") ORDER BY nome;";
            }else{
                    query+= "where cf.PessoaFisica_idPessoaFisica = pf.idPessoaFisica AND pf.Pessoa_id = p.id AND cf.Cliente_idCliente = c.idCliente AND (p.nome like '"+chave+"%') ORDER BY nome;";
                }

             System.out.println(query);
             return query;
         }

         public static String queryRemoveFisico(Fisico fis){
             String query = "DELETE FROM Pessoa where id ='"+fis.getPessoa().getId()+"';";
             return query;
         }

         public static String queryJuridicoInsert(Juridico jur){
             String query;
             query = " call inserirClienteJuridico('"+jur.getPessoa().getNome()+"','"+jur.getPessoa().getTelefone()+"','"+jur.getPessoa().getEndereco()+"','"+jur.getPessoa().getCEP()+"','";
             query += jur.getPessoa().getNumEnd()+"','"+jur.getPessoa().getBairro()+"','"+jur.getPessoa().getEstado()+"','"+jur.getPessoa().getCidade()+"','"+jur.getCNPJ()+"','"+jur.getIE()+"','"+jur.getNomeFantasia()+"','";
             query += jur.getTelFax()+"','"+jur.getEmail()+"','"+jur.getOutrasInf()+"',"+ jur.getTaxa()+","+jur.getValorFixo()+","+jur.getDesconto()+",'"+jur.getNomeFaturante()+"','"+jur.getPessoa().getComplemento()+"',@erro);";
             return query;
         }
         public static String queryJuridicoAlterar(Juridico jur){
             String query;
             query = " call alterarClienteJuridico("+jur.getPessoa().getId()+","+jur.getId()+",'"+jur.getPessoa().getNome()+"','"+jur.getPessoa().getTelefone()+"','"+jur.getPessoa().getEndereco()+"','"+jur.getPessoa().getCEP()+"','";
             query += jur.getPessoa().getNumEnd()+"','"+jur.getPessoa().getBairro()+"','"+jur.getPessoa().getEstado()+"','"+jur.getPessoa().getCidade()+"','"+jur.getCNPJ()+"','"+jur.getIE()+"','"+jur.getNomeFantasia()+"','";
             query += jur.getTelFax()+"','"+jur.getEmail()+"','"+jur.getOutrasInf()+"',"+ jur.getTaxa()+","+jur.getValorFixo()+","+jur.getDesconto()+",'"+jur.getNomeFaturante()+"','"+jur.getPessoa().getComplemento()+"',@erro);";
             return query;
         }

         public static String queryConsultaJuridico(String chave, int tipo){
             String query;
             query = "Select nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,";
             query +="telFax,email,outrasInf,taxa,valorFixo,desconto,";
             query +="id,idCliente,CNPJ,inscriEstadual,nomeFantasia,nomeFaturante,complemento ";
             query+= "from Juridico as j, Pessoa as p, Cliente as c ";
             if(tipo == 1){
                query+= "where j.Pessoa_id = p.id AND j.Cliente_idCliente = c.idCliente AND (j.idPessoa="+chave+") ORDER BY nome;";
             } else if(tipo == 2){
                    query+= "where j.Pessoa_id = p.id AND j.Cliente_idCliente = c.idCliente AND (j.CNPJ like '"+chave+"%') ORDER BY nome;";
             }else if(tipo ==5){
                       query+= "where j.Pessoa_id = p.id AND j.Cliente_idCliente = c.idCliente AND (j.Cliente_idCliente="+chave+") ORDER BY nome;";
             } else {
                    query+= "where j.Pessoa_id = p.id AND j.Cliente_idCliente = c.idCliente AND (p.nome like '"+chave+"%') ORDER BY nome;";
                }

             return query;
         }

         public static String queryRemoveJuridico(Juridico jur){
             String query = "DELETE FROM Pessoa where id ='"+jur.getPessoa().getId()+"';";
             return query;
         }

         public static String queryVeiculoInsert(Veiculo vei){
             String query;
             query = " INSERT INTO Veiculo(Proprietario,placa,cidade,UF,chassi,renavam,TipoContaCarroceria,anoFabricacao,Modelo,Fabricante,cor)";
             query += " VALUES ("+vei.getPro().getId()+",'"+vei.getPlaca()+"','"+vei.getCidade()+"','"+vei.getUF()+"','"+vei.getChassi()+"','"+vei.getRenavam()+"',";
             query += "'"+vei.getTipoCarroceria()+"','"+vei.getAnoFabricacao()+"','"+vei.getModelo()+"','"+vei.getFabricante()+"','"+vei.getCor()+"');";
          
             return query;
         }

         public static String queryConsultaVeiculo(String chave, int tipo){
             String query;
             query = "Select idVeiculo,Proprietario,placa,v.cidade,UF,chassi,renavam,TipoContaCarroceria,";
             query +="anoFabricacao,Modelo,Fabricante,cor,id,nome,telefone,endereco,CEP,numEnd,bairro,estado,p.cidade,complemento ";
             query+= "from Veiculo as v, Pessoa as p ";
             if(tipo == 1){
                query+= "where v.Proprietario=p.id and  v.placa like '"+chave+"%' ORDER BY placa;";
             }else if(tipo==5){
                 query+= "where v.Proprietario=p.id and v.idVeiculo="+chave+" ORDER BY placa";
             } else {
                    query+= "where v.Proprietario=p.id and v.renavam like'"+chave+"%' ORDER BY placa";
             }

             return query;
         }
         private static String queryAlteraVeiculo(Veiculo vei) {
                String query;
                query = "UPDATE Veiculo SET Proprietario="+vei.getPro().getId()+",placa='"+vei.getPlaca()+"',cidade='"+vei.getCidade();
                query += "',UF='"+vei.getUF()+"',chassi='"+vei.getChassi()+"',renavam='"+vei.getRenavam()+"',TipoContaCarroceria='"+vei.getTipoCarroceria()+"',";
                query += "anoFabricacao='"+vei.getAnoFabricacao()+"',Modelo='"+vei.getModelo()+"',Fabricante='"+vei.getFabricante()+"',cor='"+vei.getCor()+"'";
                query += " where idVeiculo="+vei.getIdVeiculo()+";";
                return query;
         }

         public static String queryRemoveVeiculo(Veiculo vei){
             String query = "DELETE FROM Veiculo where idVeiculo ="+vei.getIdVeiculo()+";";
             return query;
         }

         public static String queryComprovanteInsert(Comprovante comp){
             String query;
             query = "INSERT INTO Comprovante(hasSeguro_idSeguro,hasSeguro_idCliente,dataComprovante,infoComplementares,segurado) ";
             query += "VALUES("+comp.getSeg().getSeg().getIdSeguro()+","+comp.getSeg().getCli().getId()+",'"+comp.getDataComprovante().formatoBanco()+"','"+comp.getInfComplementares()+"','"+comp.getSegurado()+"');";


             return query;
         }

         public static String queryConsultaComprovante(String chave){
             String query;
             query = "Select idComprovante,hasSeguro_idSeguro,hasSeguro_idCliente,dataComprovante,infoComplementares,segurado ";
             query+= "from Comprovante as c ";
             query+= "where dataComprovante= '"+chave+"';";

             return query;
         }

         public static String queryRemoveComprovante(Comprovante comp){
             String query = "DELETE FROM Comprovante where idComprovante ='"+comp.getIdComprovante()+"';";
             return query;
         }

         public static String queryContaPagarInsert(ContaPagar contP){
             String query;
             query = "call inserirContaPagar('"+contP.getDocumento()+"','"+contP.getEmissao().formatoBanco()+"','";
             query += contP.getLocalCobranca()+"','"+contP.getEmitente()+"','"+contP.getTipo().getTipoConta()+"','"+contP.getFunc().getId()+"','";
             query += contP.getFunc().getIdPessoaFisica()+"', @erro, @IDconta, @IDcontaPagar);";
             return query;
         }

             // int idConta, String documento, Data emissao, Data vencimento, String localCobranca, TipoConta tipo, Funcionario func, String emitente, int idContaPagar)
         public static String queryConsultaContaPagar(String chave, int tipo){
             String query;
             query ="Select PessoaFisica_idPessoaFisica, emitente,  idConta,documento,emissao,localCobranca, idtipo,tipoConta,idContaApagar ";
             query +="from Conta as c, ContaApagar as cp, TipoConta as tc, Parcela as p, Funcionario as f ";
             query +="where c.idConta = cp.Conta_idConta AND c.TipoConta_idtipo = tc.idtipo AND p.ContaApagar_Conta_idConta = c.idConta AND ";
             query +="f.PessoaFisica_idPessoaFisica = cp.Funcionario_PessoaFisica_idPessoaFisica ";
             if(tipo ==1)
                 query += "AND c.documento = '"+chave+"';";
             else if(tipo==2)
                 query +="AND c.emitente like '"+chave+"%';";
             else if(tipo==3)
                 query+= "AND Funcionario_PessoaFisica_Pessoa_id ='"+chave+"';";
             else if(tipo==4)
                 query += "AND c.idConta = "+chave+";";
             return query;
         }

         public static String queryRemoveContaPagar(ContaPagar contP){
             String query = "DELETE FROM Conta where idConta ='"+contP.getIdConta()+"';";
             return query;
         }

         public static String queryContaPagarAlterar(ContaPagar contP){
             String query;
             query = " call alterarContaPagar("+contP.getIdConta()+",'"+contP.getDocumento()+"','"+contP.getEmissao().formatoBanco();
             query += "',"+contP.getTipo().getIdTipo()+",'"+contP.getLocalCobranca()+"','"+contP.getEmitente()+"','";
             query += contP.getTipo().getTipoConta()+"',"+contP.getFunc().getId()+","+contP.getFunc().getIdPessoaFisica()+",@erro);";
             return query;
         }

        public static String queryParcelasInsert(Parcela parc){
             String query;
             query = "call inserirParcela('"+parc.getConta().getIdConta()+"','"+parc.getConta().getIdContaPagar()+"','"+parc.getVencimento().formatoBanco()+"','"+parc.getValor()+"','";
             query += parc.getNumParcela()+"', @erro);";
             return query;
         }

         public static String queryRemoveParcelas(int idConta){
             String query = "DELETE FROM Parcela where idParcela ='"+idConta+"';";
             return query;
         }

         public static String queryParcelasAlterar(Parcela parc){
             String query;
             query = " call alterarParcela("+parc.getIdParcela()+","+parc.getConta().getIdConta()+","+parc.getConta().getIdContaPagar()+",'"+parc.getVencimento().formatoBanco()+"',"+parc.getValor()+",";
             query += parc.getNumParcela()+", @erro);";
             return query;
         }

         public static String queryConsultaParcela(String chave, int tipo){
             String query;
             query = "Select idParcela,ContaApagar_Conta_idConta,ContaApagar_idContaApagar,vencimento,numParcela,valor ";
             query+= "from Parcela as p, ContaApagar as ca, Conta as c, Funcionario as f  ";
             query+= "where p.ContaApagar_idContaApagar = ca.idContaApagar AND ca.Conta_idConta=c.idConta  AND ca.Funcionario_PessoaFisica_idPessoaFisica = f.PessoaFisica_idPessoaFisica AND ";
             if(tipo==1)
                query+= "c.documento = '"+chave+"' ORDER BY vencimento";
             else if(tipo==2)
                 query+= " p.vencimento ='"+chave+"' ORDER BY vencimento";
             else if(tipo==3)
                 query +=" p.vencimento BETWEEN "+chave+";";
             else if(tipo==4)
                 query += "f.PessoaFisica_idPessoaFisica="+chave+" ORDER BY vencimento";
             return query;
         }

        public static String ConsultaProprietario(String chave, int tipo){
            String query="";
            if(tipo==1){
                query = "select id,nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,complemento ";
                query += "from Pessoa as p, PessoaFisica as pf where p.id = pf.idPessoaFisica ";
                query += "AND pf.CPF like '"+chave+"%' ORDER BY nome;";
            } else if (tipo == 2) {
                query = "select id,nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,complemento";
                query += " from Pessoa as p, Juridico as j where p.id=j.Pessoa_id";
                query += " AND j.CNPJ like '"+chave+"%' ORDER BY nome";
            }else{
                 query = "select id,nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,complemento";
                query += " from Pessoa as p where";
                query += " nome like '"+chave+"%' ORDER BY nome";
            }
            System.out.println(query);
            return query;
     }

    private static String queryConsultaProprietario(String chave) {
        String query;
        query = "SELECT id,nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,complemento";
        query += " from Pessoa where id="+chave+";";
        return query;
    }

    public static String queryClientHasSeguro(Cliente_has_Seguro s,int idSeguro){
        String query;
        query = "INSERT INTO Cliente_has_Seguro(Seguro_idSeguro,Cliente_idCliente,valorFatura,valorJaPago)";
        query +=" VALUES("+idSeguro+","+s.getCli().getId()+","+s.getValorFatura()+","+s.getValorJaPago()+");";
        return query;
    }


    public static String queryConsultaSeguro(String chave, int tipo){
        String query;
        query = "Select idSeguro,Remetente,Destinatario,Motorista_PessoaFisica_idPessoaFisica,Funcionario_PessoaFisica_idPessoaFisica,";
        query += "Veiculo_idVeiculo,Mercadoria_idMercadoria,valorSeguro,valorICMS,CTRC,outros,total,dataSeguro,strc,vendedor ";
        query += "from Seguro where";
        if(tipo == 1){
            query += " strc='"+chave+"' ORDER BY strc asc;";
        }else if(tipo ==2){
             query += " valorSeguro >="+chave+" ORDER BY strc asc;";
        }else if(tipo ==3){
             query += " Remetente="+chave+" ORDER BY strc asc;";
        }else if(tipo ==4){
              query += " Destinatario="+chave+" ORDER BY strc asc;";
        }else if(tipo ==5){

        }else if(tipo==6){
            query += " idSeguro ="+chave+" ORDER BY strc asc;";
        }

        return query;
    }
    public static String queryConsultaCliSeg(int chave,String dataInicio,String dataFim){
        String query;
        query ="select Cliente_idCliente,valorFatura,valorJaPago,Seguro_idSeguro ";
        query += "from Cliente as c, Cliente_has_Seguro as cs, Seguro as s ";
        query += "where c.idCliente = cs.Cliente_idCliente AND s.idSeguro = cs.Seguro_idSeguro ";
        query += "AND c.idCliente="+chave+" AND s.dataSeguro BETWEEN '"+dataInicio+"' AND '"+dataFim+"' ORDER BY dataSeguro;";
        return query;
    }
     public static String queryConsultaCliSegSemData(int chave){
        String query;
        query ="select Cliente_idCliente,valorFatura,valorJaPago,Seguro_idSeguro ";
        query += "from Cliente as c, Cliente_has_Seguro as cs, Seguro as s ";
        query += "where c.idCliente = cs.Cliente_idCliente AND s.idSeguro = cs.Seguro_idSeguro ";
        query += "AND c.idCliente="+chave+";";
        return query;
    }

     public static String queryConsultaCliSeg(int chave){
        String query;
        query ="select Cliente_idCliente,valorFatura,valorJaPago,Seguro_idSeguro ";
        query += "from Cliente as c, Cliente_has_Seguro as cs, Seguro as s ";
        query += "where c.idCliente = cs.Cliente_idCliente AND s.idSeguro = cs.Seguro_idSeguro ";
        query += "AND s.idSeguro="+chave+";";
        return query;
    }
    public static String queryRemoveSeguro(Seguro seg){
        String query;
        query = "DELETE FROM Seguro where idSeguro="+seg.getIdSeguro()+";";
        return query;
    }

    private static String queryConsultaMercadoria(String chave) {
        String query;
        query ="select idMercadoria,nome,naturezaCarga,peso,quantidade,especie,valorMercadoria,peso ";
        query +="from Mercadoria as m, TipoMercadoria as tm ";
        query +=" where m.TipoMercadoria_idTipo=tm.idTipo AND m.idMercadoria="+chave+";";
        return query;
    }

    

    private static String querySegDia(String data) {
        String query;
        query = "select idSeguro from logSeguro where dataCadastro='"+data+"';";
        return query;
    }
    private static String queryEmp(int i) {
        String query;
        //CnpjEmp, String razao, String IE, String fantasia, String endereco, String cep, String municipio, String contato, String bairro, String telefone, String celular,String estado)
        query = "select CNPJ,nome,IE,fantasia,endereco,CEP,cidade,contato,bairro,foneFixo,celular,UF from Empresa where idEmpresa="+i+";";
        return query;
    }

    public static String queryValidaCPF(String chave){
        String query= "select speed.validarCpf('"+chave+"');";
        return query;
    }
    public static String queryValidaCNPJ(String chave){
        String query = "select speed.fc_validarCNPJ('"+chave+"');";
        return query;
    }
    public static String queryBuscaCPF(String chave){
        String query ="select cpf from PessoaFisica where cpf like'"+chave+"%';";
        return query;
    }
    public static String queryBuscaCNPJ(String chave){
        String query = "select CNPJ from Juridico where CNPJ like'"+chave+"%';";
        return query;
    }
    public static String queryVariasBuscasSeguroJuridicos(String chave){
        String query = "select idCliente ";
        query += "from Cliente as c JOIN Juridico as j ON c.idCliente=j.Cliente_idCliente JOIN Pessoa as p ";
        query += "ON j.Pessoa_id=p.id where p.nome like '"+chave+"%'; ";
        return query;
    }
    public static String queryVariasBuscasSeguroFisico(String chave){
        String query = "select idCliente ";
        query += "from Cliente as c JOIN ClienteFisico as f ON c.idCliente=f.Cliente_idCliente JOIN Pessoa as p ";
        query += "ON f.PessoaFisica_Pessoa_id=p.id ";
        query += "where p.nome like '"+chave+"%'";
        return query;
    }
    
      private static String queryNovaMercadoria(String text) {
            String query = "INSERT INTO TipoMercadoria(nome) VALUES('"+text+"');";
            return query;
    }
      private static String querySelecionarMercadorias(){
          String query = "select nome from TipoMercadoria";
          return query;
      }

    private static String queryNovaConta(String text) {
       String query = "INSERT INTO TipoConta(TipoConta) VALUES('"+text+"');";
       return query;
    }

     private static String querySelecionarNovaConta() {
        String query = "select TipoConta from TipoConta";
        return query;
    }

    private static String queryInserirEmpresa(Emp empresa) {
       String query = "INSERT INTO Empresa (nome,fantasia,foneFixo,celular,CNPJ,IE,endereco,CEP,cidade,UF,bairro) ";
        query += "VALUES ('"+empresa.getRazao()+"','"+empresa.getFantasia()+"','"+empresa.getTelefone()+"','"+empresa.getCelular()+"','"+empresa.getCnpjEmp()+"','";
        query += empresa.getIE()+"','"+empresa.getEndereco()+"','"+empresa.getCep()+"','"+empresa.getMunicipio()+"','"+empresa.getEstado()+"','"+empresa.getBairro()+"');";
        return query;
    }

      private static String updateEmpresa(Emp emp) {
       String query ="UPDATE Empresa SET nome='"+emp.getRazao()+"',fantasia='"+emp.getFantasia()+"',foneFixo='"+emp.getCelular()+"',celular='"+emp.getCelular()+"',";
       query +="CNPJ='"+emp.getCnpjEmp()+"',IE='"+emp.getIE()+"',endereco='"+emp.getEndereco()+"',CEP='"+emp.getCep()+"',cidade='"+emp.getMunicipio()+"',UF='"+emp.getEstado()+"',bairro='"+emp.getBairro()+"';";
       return query;
    }
      private static String queryValidaSTRC(String STRC) {
        String query = "select STRC from Seguro where STRC='"+STRC+"';";
        return query;
    }

/**
     * QUERY PARA OS GRAFICOS monta as colunas e a query para o grafico
     */
    public static String obtemVendas1(String dataInicio,String dataFim,int vendido){

        /**
         * essa query verifica todos os Seguros que tem os mesmo id de carga e empresa, e que estao na data fornecida pelo usuario
         * assim ele agrupa os valores pelo nome das empresas, soma o lucro delas, e escolhe o tipo de ordenacao
         */

         String query ="select nome, SUM(valorFatura) as 'soma' ";
         query += "FROM Seguro AS s JOIN Cliente_has_Seguro as c ON s.idSeguro = c.Seguro_idSeguro ";
         query +="JOIN Cliente As cli ON cli.idCliente = c.Cliente_idCliente JOIN ClienteFisico as f ON cli.idCliente= f.Cliente_idCliente ";
         query +="JOIN Pessoa as p ON p.id = f.PessoaFisica_Pessoa_id ";
         query +="WHERE s.dataSeguro BETWEEN '"+dataInicio+"' AND '"+dataFim+"' ";
         query +="GROUP BY nome ";
        if(vendido==1)
            query+=" ORDER BY soma DESC";
        else
            query+= " ORDER BY soma";
        return query;
    }

       public static String obtemVendas2(String dataInicio,String dataFim,int vendido){

        /**
         * essa query verifica todos os Seguros que tem os mesmo id de carga e empresa, e que estao na data fornecida pelo usuario
         * assim ele agrupa os valores pelo nome das empresas, soma o lucro delas, e escolhe o tipo de ordenacao
         */

        String query ="select nome, SUM(valorFatura) as 'soma' ";
        query += "FROM Seguro AS s JOIN Cliente_has_Seguro as c ON s.idSeguro = c.Seguro_idSeguro ";
        query += "JOIN Cliente As cli ON cli.idCliente = c.Cliente_idCliente JOIN Juridico as j ON ";
        query += "cli.idCliente= j.Cliente_idCliente ";
        query += "JOIN Pessoa as p ON p.id = j.Pessoa_id ";
        query += "WHERE s.dataSeguro BETWEEN '"+dataInicio+"' AND '"+dataFim+"' ";
        query += "GROUP BY nome ";
        if(vendido==1)
            query+=" ORDER BY soma DESC";
        else
            query+= " ORDER BY soma";
        return query;
    }

    /**
     * query para pegar os valores vendidos no mes informados pelo usuario
     */
    public static String vendasMes(String dataInicio,String dataFim) {

        //a query soma os valore de lucro, obtem o mes de cada grupo feito pela calsula group by month() que pega o carcter de mes
        // assim ela volta o nome de cada mes de acordo com seu caracter
        //e procora pelos dados no limite da data informada pelo usuario
        String query ="";
        query = "SELECT SUM(s.valorSeguro) as 'lucro', ";
        query += "CASE MONTH(s.dataSeguro) ";
        query += " WHEN 1 THEN 'janeiro' WHEN 2 THEN 'fevereiro' WHEN 3 THEN 'março' WHEN 4 THEN 'abril' ";
        query += "WHEN 5 THEN 'maio' WHEN 6 THEN 'junho' WHEN 7 THEN 'julho' WHEN 8 THEN 'agosto' ";
        query += "WHEN 9 THEN 'setembro' WHEN 10 THEN 'outubro' WHEN 11 THEN 'novembro' WHEN 12 THEN 'dezembro' ";
        query += "END as 'mes' ";
        query += "FROM Seguro s ";
        query += "WHERE s.dataSeguro BETWEEN '"+dataInicio+"' AND '"+dataFim+"' ";
        query += "GROUP BY MONTH(s.dataSeguro); ";
        return query;
    }

    private static String queryBuscaCPF(int id) {
        String query ="select CPF from PessoaFisica where Pessoa_id = "+id+";";
        return query;
    }

    private static String queryBuscaCNPJ(int id) {
         String query ="select CNPJ from Juridico where Pessoa_id = "+id+";";
        return query;
    }

    private static String queryPlaca(String text) {
        String query = "select placa from Veiculo where placa ='"+text+"';";
        return query;
    }

    private static String queryDataCNH() {
            String query = "Select nome,telefone,endereco,CEP,numEnd,bairro,estado,cidade,id,";
             query +="idPessoaFisica,CPF,ufRG,RG,orgExRG,";
             query +="CNH,categoriaCNH,nomePai,nomeMae,obs,validadeCNH,referenciaPessoal,telefoneReferencia,celular,dataNascimento,apelido,complemento ";
             query+= "from Motorista as m, Pessoa as p, PessoaFisica as pf ";
             query += "WHERE m.PessoaFisica_idPessoaFisica= pf.idPessoaFisica AND pf.Pessoa_id=p.id AND TO_DAYS(validadeCNH) - TO_DAYS(NOW())  <= 10;";
             return query;
    }
    private static String queryContaReceber(){
        String query ="select Cliente_idCliente,SUM(valorfatura-valorJaPago) from Seguro as s, Cliente_has_Seguro as cs ";
        query +="WHERE TO_DAYS(NOW()) - TO_DAYS(dataSeguro) <= 30 AND s.idSeguro = cs.Seguro_idSeguro ";
        query += "GROUP BY(cs.Cliente_idCliente);";
       return query;
    }
    private static String queryMenorData(){
        String query = "select MIN(dataSeguro) as dataDoSeguro ";
        query += "from Seguro WHERE TO_DAYS(NOW()) - TO_DAYS(dataSeguro) <= 30 ";
        query += "ORDER BY dataSeguro;";
        return query;
    }
    private static String queryRTFC(){
       String  query = "select taxa,origem,destino ";
        query += " from RTCF as r ";
        return query;
    }

    private static String queryVendasFunc(String inicio, String Fim) {
        String query = "select nome, SUM(valorSeguro) as valor ";
        query += "from Seguro as s, Pessoa as p ";
        query += "where s.Funcionario_PessoaFisica_Pessoa_id = p.id AND  (s.dataSeguro BETWEEN '"+inicio+"' AND '"+Fim+"') GROUP BY nome";
        return query;
    }

    private static String queryBalancoSeguros(String data) {
        String query ="select SUM(valorSeguro) as Seguros ";
        query += "from  Seguro as s ";
        query += "where  s.dataSeguro='"+data+"';";
        return query;
    }
    private static String queryBalancoConta(String data){
        String query = "select  SUM(p.valor) as valor ";
        query +="from Parcela as p ";
        query +="where p.vencimento='"+data+"';";
        return query;
    }



}